MetaFork: A Metalanguage for Concurrency Platforms Targeting Multicores

In the past decade the pervasive ubiquitous of multicore processors has stimulated a constantly increasing effort in the development of concurrency platforms (such as CilkPlus, OpenMP, Intel TBB) targeting those architectures. While those programming languages are all based on the fork-join parallelism model, they largely differ on their way of expressing parallel algorithms and scheduling the corresponding tasks. Therefore, developing programs involving libraries written with several of those languages is a challenge. Nevertheless there is a real need for facilitating interoperability between concurrency platforms. Consider for instance the field of symbolic computation. The DMPMC library (from the TRIP project www.imcce.fr/trip developed at the Observatoire de Paris) provides sparse polynomial arithmetic and is entirely written in OpenMP meanwhile the BPAS library (from the Basic Polynomial Algebra Subprograms www.bpaslib.org developed at the University of Western Ontario) provides dense polynomial arithmetic is entirely written in CilkPlus. Polynomial system solvers require both sparse and dense polynomial arithmetic and thus could advantage of a combination of the DMPMC and BPAS libraries. Unfortunately, the run-time systems of CilkPlus and OpenMP cannot cooperate since their schedulers are based on different strategies, namely work stealing and work sharing, respectively. Therefore, an automatic translation mechanism is needed between CilkPlus and OpenMP. Another motivation for such software tool is comparative implementation with the objective of narrowing performance bottleneck. The underlying observation is that the same multithreaded algorithm, based on the fork-join parallelism model, implemented with two different concurrency platforms, say CilkPlus and OpenMP, could result in very different performance, often very hard to analyze and compare. If one code scales well while the other does not, one may suspect an efficient implementation of the latter as well as other possible causes such as higher parallelism overheads. Translating the inefficient code to the other language can help narrowing the problem. Indeed, if the translated code still does not scale one can suspect an implementation issue (say the programmer missed to parallelize one portion of the algorithm) whereas if it does scale, then one can suspect a parallelism overhead issue in the original code (say the grain-size of the parallel for-loop is too small). In this note, we propose MetaFork, a metalanguage for multithreaded algorithms based on the fork-join parallelism model [5] and targeting multicore architectures. By its parallel programming constructs, this language is currently a super-set of CilkPlus [4, 7, 9] and OpenMP Tasks [1]. However, this language does not compromise itself in any scheduling strategies (work stealing [6], work sharing, etc.) Thus, it does not make any assumptions about the run-time system. Based on the motivations stated above, a driving application of MetaFork is to facilitate automatic translations of programs between the above mentioned concurrency platforms. To